package com.example.print_sdk;


import android.graphics.Bitmap;
import android.util.Log;


public class ImagePrintUtil {

    private SerialManager printer=null;
    protected byte[] _cmd={0, 0, 0, 0, 0, 0, 0, 0, 0};

    public ImagePrintUtil(SerialManager p) {
        printer=p;
    }

    /**
     * Name：printImage，Print the monochrome bitmap
     *
     * @param bitmap
     */
    public void printImage(Bitmap bitmap) {
        long start=System.currentTimeMillis ();
        int width=bitmap.getWidth ();
        int height=bitmap.getHeight ();
        byte[] data=new byte[]{0x1B, 0x33, 0x00};//Set the row spacing to 0.
        printer.escCommand (data);
        data[0]=(byte) 0x00;
        data[1]=(byte) 0x00;
        data[2]=(byte) 0x00;    //reset parameters

        int pixelColor;

        // ESC * m nL nH bitmap
        byte[] escBmp=new byte[]{0x1B, 0x2A, 0x00, 0x00, 0x00};
        escBmp[2]=(byte) 0x21;
        //nL, nH
        escBmp[3]=(byte) (width % 256);
        escBmp[4]=(byte) (bitmap.getWidth () / 256);

        // print each line
        for (int i=0; i < height / 24 + 1; i++) {
            printer.escCommand (escBmp);
            for (int j=0; j < width; j++) {
                for (int k=0; k < 24; k++) {
                    if (((i * 24) + k) < height) {
                        pixelColor=bitmap.getPixel (j, (i * 24) + k);
                        if (pixelColor != -1) {
                            data[k / 8]+=(byte) (127 >> (k % 8));
                        }
                    }
                }
                printer.escCommand (data);
                //reset parameters
                data[0]=(byte) 0x00;
                data[1]=(byte) 0x00;
                data[2]=(byte) 0x00;

            }
            //out
            byte[] byte_send1=new byte[3];
            byte_send1[0]=0x1B;
            byte_send1[1]=0x4A;
            byte_send1[2]=0x00;
            printer.escCommand (byte_send1);
        }
        byte[] byte_end_sn=new byte[3]; // 一票一控结束
        byte_end_sn[0]=0x1D;
        byte_end_sn[1]=0x23;
        byte_end_sn[2]=0x45;
        printer.escCommand (byte_end_sn);
        long end=System.currentTimeMillis ();
        Log.e ("a", "耗时2: " + (end - start) + "ms");
    }

    public byte[] draw2PxPoint(Bitmap bmp) {
        //先设置一个足够大的size，最后在用数组拷贝复制到一个精确大小的byte数组中
        int size=bmp.getWidth () * bmp.getHeight () / 8 + 1000;
        byte[] tmp=new byte[size];
        int k=0;
        // 设置行距为0
        tmp[k++]=0x1B;
        tmp[k++]=0x33;
        tmp[k++]=0x00;
        // 居中打印
        tmp[k++]=0x1B;
        tmp[k++]=0x61;
        tmp[k++]=1;
        for (int j=0; j < bmp.getHeight () / 24f; j++) {
            tmp[k++]=0x1B;
            tmp[k++]=0x2A;// 0x1B 2A 表示图片打印指令
            tmp[k++]=33; // m=33时，选择24点密度打印
            tmp[k++]=(byte) (bmp.getWidth () % 256); // nL
            tmp[k++]=(byte) (bmp.getWidth () / 256); // nH
            for (int i=0; i < bmp.getWidth (); i++) {
                for (int m=0; m < 3; m++) {
                    for (int n=0; n < 8; n++) {
                        byte b=px2Byte (i, j * 24 + m * 8 + n, bmp);
                        tmp[k]+=tmp[k] + b;
                    }
                    k++;
                }
            }
            tmp[k++]=10;// 换行
        }
        // 恢复默认行距
        tmp[k++]=0x1B;
        tmp[k++]=0x32;

        byte[] result=new byte[k];
        System.arraycopy (tmp, 0, result, 0, k);
        return result;
    }

    /**
     * @param bitmap
     * @return 将图片转数组
     */
    public byte[] draw2PxPoint2(Bitmap bitmap) {
        int scaleHeight=bitmap.getHeight ();
        //宽度要是8的倍数
        int bitWidth=(bitmap.getWidth () + 7) / 8 * 8;
        int width=bitmap.getWidth ();
        int data[]=new int[width * scaleHeight];
        byte dataVec[]=new byte[bitWidth * scaleHeight / 8 + 8];
        long start=System.currentTimeMillis ();
        dataVec[0]=0x1D;
        dataVec[1]=0x76;
        dataVec[2]=0x30;
        dataVec[3]=0;
        dataVec[4]=(byte) (bitWidth / 8 % 256);
        dataVec[5]=(byte) (bitWidth / 8 / 256);
        dataVec[6]=(byte) (scaleHeight % 256);
        dataVec[7]=(byte) (scaleHeight / 256);
        int k=8;
        bitmap.getPixels (data, 0, width, 0, 0, width, scaleHeight);
        for (int h=0; h < scaleHeight; h++) {
            for (int w=0; w < bitWidth; w+=8) {
                int value=0;
                for (int i=0; i < 8; i++) {
                    int index=h * width + w + i;
                    if (w + i >= width) {
                        // 超度图片的大小零填充
                        value|=0;
                    } else {
                        //这里就是高低在前低位在后
                        value|=px2Byte (data[index]) << (7 - i);
                    }
                }
                dataVec[k++]=(byte) value;
            }
        }
        return dataVec;
    }


    public static byte px2Byte(int pixel) {

        byte b;
        int red=(pixel & 0x00ff0000) >> 16; // 取高两位
        int green=(pixel & 0x0000ff00) >> 8; // 取中两位
        int blue=pixel & 0x000000ff; // 取低两位
        int gray=RGB2Gray (red, green, blue);
        if (gray < 127) {
            b=1;
        } else {
            b=0;
        }
        return b;
    }


    /**
     * 灰度图片黑白化，黑色是1，白色是0
     *
     * @param x   横坐标
     * @param y   纵坐标
     * @param bit 位图
     * @return
     */
    public static byte px2Byte(int x, int y, Bitmap bit) {
        if (x < bit.getWidth () && y < bit.getHeight ()) {
            byte b;
            int pixel=bit.getPixel (x, y);
            int red=(pixel & 0x00ff0000) >> 16; // 取高两位
            int green=(pixel & 0x0000ff00) >> 8; // 取中两位
            int blue=pixel & 0x000000ff; // 取低两位
            int gray=RGB2Gray (red, green, blue);
            if (gray < 128) {
                b=1;
            } else {
                b=0;
            }
            return b;
        }
        return 0;
    }



    /**
     * 图片灰度的转化
     *
     * @param r
     * @param g
     * @param b
     * @return
     */
    private static int RGB2Gray(int r, int g, int b) {
        int gray=(int) (0.3 * r + 0.59 * g + 0.11 * b);  //灰度转化公式
        return gray;
    }



}
